shared source/sscli20/samples/compilers/myc/src/exe.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="exe.cs" company="Microsoft">
   3 //
   4 //      Copyright (c) 2006 Microsoft Corporation.  All rights reserved.
   5 //
   6 //      The use and distribution terms for this software are contained in the file
   7 //      named license.txt, which can be found in the root of this distribution.
   8 //      By using this software in any fashion, you are agreeing to be bound by the
   9 //      terms of this license.
  10 //
  11 //      You must not remove this notice, or any other, from this software.
  12 //
  13 // </copyright>
  14 //------------------------------------------------------------------------------
  15
  16 namespace MyC
  17 {
  18 using System;
  19 using System.Reflection.Emit;
  20 using System.Reflection;
  21 using System.Collections;
  22
  23 public class Exe
  24 {
  25 AppDomain appdomain;            // assembly domain
  26 AssemblyName appname;           // assembly name
  27 AssemblyBuilder appbuild;       // assembly builder
  28 ModuleBuilder emodule;          // module builder
  29 TypeBuilder eclass;             // current class
  30 MethodBuilder emethod;          // current method
  31 String filename;
  32 String classname;
  33 Hashtable opcodehash;
  34 ILGenerator il;
  35 System.Diagnostics.SymbolStore.ISymbolDocumentWriter srcdoc;    // debug source file
  36 bool localsdone = false;        // track if we are now emitting instructions
  37
  38 public void initOpcodeHash()
  39   {
  40   opcodehash = new Hashtable(32); // default initial size
  41   opcodehash["neg"] = OpCodes.Neg;
  42   opcodehash["mul"] = OpCodes.Mul;
  43   opcodehash["div"] = OpCodes.Div;
  44   opcodehash["add"] = OpCodes.Add;
  45   opcodehash["sub"] = OpCodes.Sub;
  46   opcodehash["not"] = OpCodes.Not;
  47   opcodehash["and"] = OpCodes.And;
  48   opcodehash["or"] = OpCodes.Or;
  49   opcodehash["xor"] = OpCodes.Xor;
  50   opcodehash["pop"] = OpCodes.Pop;
  51
  52   opcodehash["br"] = OpCodes.Br;
  53   opcodehash["beq"] = OpCodes.Beq;
  54   opcodehash["bge"] = OpCodes.Bge;
  55   opcodehash["ble"] = OpCodes.Ble;
  56   opcodehash["blt"] = OpCodes.Blt;
  57   opcodehash["bgt"] = OpCodes.Bgt;
  58   opcodehash["brtrue"] = OpCodes.Brtrue;
  59   opcodehash["brfalse"] = OpCodes.Brfalse;
  60
  61   opcodehash["cgt"] = OpCodes.Cgt;
  62   opcodehash["clt"] = OpCodes.Clt;
  63   opcodehash["ceq"] = OpCodes.Ceq;
  64
  65   opcodehash["ldc.i4.-1"] = OpCodes.Ldc_I4_M1;
  66   opcodehash["ldc.i4.0"] = OpCodes.Ldc_I4_0;
  67   opcodehash["ldc.i4.1"] = OpCodes.Ldc_I4_1;
  68   opcodehash["ldc.i4.2"] = OpCodes.Ldc_I4_2;
  69   opcodehash["ldc.i4.3"] = OpCodes.Ldc_I4_3;
  70   opcodehash["ldc.i4.4"] = OpCodes.Ldc_I4_4;
  71   opcodehash["ldc.i4.5"] = OpCodes.Ldc_I4_5;
  72   opcodehash["ldc.i4.6"] = OpCodes.Ldc_I4_6;
  73   opcodehash["ldc.i4.7"] = OpCodes.Ldc_I4_7;
  74   opcodehash["ldc.i4.8"] = OpCodes.Ldc_I4_8;
  75   }
  76
  77 public Exe(String name)
  78   {
  79   filename = name;
  80   initOpcodeHash();
  81   }
  82
  83 AssemblyName getAssemblyName(string s)
  84   {
  85   AssemblyName a = new AssemblyName();
  86   a.Name = filename+"_assembly";
  87   return a;
  88   }
  89
  90 public void BeginModule(string ifile)
  91   {
  92   appdomain = System.Threading.Thread.GetDomain();
  93   appname = getAssemblyName(filename);
  94   appbuild = appdomain.DefineDynamicAssembly(appname,
  95                                              AssemblyBuilderAccess.Save,
  96                                              Io.genpath);
  97   emodule = appbuild.DefineDynamicModule(
  98                 filename+"_module",
  99                 Io.GetOutputFilename(),
 100                 Io.gendebug);
 101   Guid g = System.Guid.Empty;
 102   if (Io.gendebug)
 103     srcdoc = emodule.DefineDocument(ifile, g, g, g);
 104
 105   }
 106
 107 public void EndModule()
 108   {
 109   try
 110     {
 111     String s = Io.GetOutputFilename();
 112     appbuild.Save(s);
 113     Console.WriteLine("Saving assembly as "+s);
 114     }
 115   catch (Exception e)
 116     {
 117     Io.ICE(e.ToString());
 118     }
 119   }
 120
 121 public void BeginClass(String name, TypeAttributes access)
 122   {
 123   classname = name;
 124   eclass = emodule.DefineType(name, access);
 125   }
 126
 127 public void EndClass()
 128   {
 129   eclass.CreateType();          // create the class
 130   }
 131
 132 /*
 133  * determine the IL static type
 134  */
 135 Type ilSType(bool sign, int type)
 136   {
 137   if (sign)
 138     {
 139     switch (type)
 140       {
 141       case Tok.T_CHAR:          return Type.GetType("System.SByte");
 142       case Tok.T_SHORT:         return Type.GetType("System.Int16");
 143       case Tok.T_DEFTYPE:       return Type.GetType("System.Int32");
 144       case Tok.T_INT:           return Type.GetType("System.Int32");
 145       case Tok.T_LONG:          return Type.GetType("System.Int32");
 146       case Tok.T_FLOAT:         return Type.GetType("System.Single");
 147       case Tok.T_DOUBLE:        return Type.GetType("System.Double");
 148       case Tok.T_VOID:          return null;
 149       default:
 150         Io.ICE("Unhandled type " + type);
 151         return null;
 152       }
 153     }
 154   else
 155     {
 156     switch (type)
 157       {
 158       case Tok.T_CHAR:          return Type.GetType("U1");
 159       case Tok.T_SHORT:         return Type.GetType("U2");
 160       case Tok.T_DEFTYPE:       return Type.GetType("U4");
 161       case Tok.T_INT:           return Type.GetType("U4");
 162       case Tok.T_LONG:          return Type.GetType("U4");
 163       default:
 164         Io.ICE("Unhandled type " + type);
 165         return null;
 166       }
 167     }
 168   }
 169
 170 /*
 171  * common routine to construct a signature string for a given varlist item
 172  * requires a destination ptr, will return the updated dest ptr
 173  */
 174 private Type genDataTypeSig(Var e)
 175   {
 176   bool sign = true;
 177   if (e == null)
 178     return null;
 179
 180   if (e.getSign() == Tok.T_UNSIGNED)    /* if var is unsigned, put it in sig */
 181     sign = false;
 182
 183   Type sig = ilSType(sign, e.getTypeId());      /* get the datatype */
 184   return (sig);
 185   }
 186
 187 void genLoad(Var e)
 188   {
 189   int id = e.getClassId();
 190   if (e == null)
 191     Io.ICE("Load instruction with no variable ptr");
 192   if (e.getLocalToken() != null)
 193     {
 194     //    LocalToken lt = (LocalToken) e.getLocalToken();
 195     LocalBuilder lt = (LocalBuilder) e.getLocalToken();
 196     il.Emit(OpCodes.Ldloc, lt);
 197     }
 198   else if (e.getFieldBuilder() != null)
 199     {
 200     FieldBuilder fb = (FieldBuilder) e.getFieldBuilder();
 201     if (id == Tok.T_STATIC)
 202       il.Emit(OpCodes.Ldsfld, fb);
 203     else
 204       il.Emit(OpCodes.Ldfld, fb);
 205     }
 206   else
 207     {
 208     int index = e.getIndex();
 209     if (id == Tok.T_PARAM)
 210       {
 211       if (index <= 256)
 212         il.Emit(OpCodes.Ldarg_S, index);
 213       else
 214         il.Emit(OpCodes.Ldarg, index);
 215       }
 216     else if (id == Tok.T_AUTO || id == Tok.T_DEFCLASS)
 217       {
 218       if (index <= 256)
 219         il.Emit(OpCodes.Ldloc_S, e.getIndex());
 220       else
 221         il.Emit(OpCodes.Ldloc, e.getIndex());
 222       }
 223     else
 224       Io.ICE("Instruction load of unknown class ("
 225                                      + e.getClassId()+")");
 226     }
 227   }
 228
 229 public void Load(IAsm a)
 230   {
 231   Var e = a.getVar();
 232   genLoad(e);
 233   }
 234
 235 public void Store(IAsm a)
 236   {
 237   Var e = a.getVar();
 238   int id = e.getClassId();
 239   if (e == null)
 240     Io.ICE("Store instruction with no variable ptr");
 241   if (e.getLocalToken() != null)
 242     {
 243     //    LocalToken lt = (LocalToken) e.getLocalToken();
 244     LocalBuilder lt = (LocalBuilder) e.getLocalToken();
 245     il.Emit(OpCodes.Stloc, lt);
 246     }
 247   else if (e.getFieldBuilder() != null)
 248     {
 249     FieldBuilder fb = (FieldBuilder) e.getFieldBuilder();
 250     if (id == Tok.T_STATIC)
 251       il.Emit(OpCodes.Stsfld, fb);
 252     else
 253       il.Emit(OpCodes.Stfld, fb);
 254     }
 255   else
 256     {
 257     int index = e.getIndex();
 258     if (id == Tok.T_PARAM)
 259       {
 260       if (index <= 256)
 261         il.Emit(OpCodes.Starg_S, index);
 262       else
 263         il.Emit(OpCodes.Starg, index);
 264       }
 265     else if (id == Tok.T_AUTO || id == Tok.T_DEFCLASS)
 266       il.Emit(OpCodes.Stloc, index);
 267     else
 268       Io.ICE("Instruction load of unknown class ("
 269                                      + e.getClassId()+")");
 270     }
 271   }
 272
 273 public void FuncBegin(IAsm a)
 274   {
 275   Var func = a.getVar();
 276   Type funcsig = genDataTypeSig(a.getVar()); /* gen return type info */
 277
 278   VarList paramlist = func.getParams(); /* get any params */
 279   Type[] paramTypes = null;     // in case no params
 280   if (paramlist.Length() > 0)
 281     {
 282     int max = paramlist.Length();
 283     paramTypes = new Type[max];
 284     for (int i = 0; i < max; i++)
 285       {
 286       Var e = paramlist.FindByIndex(i);
 287       paramTypes[i] = genDataTypeSig(e);
 288       }
 289     }
 290
 291   emethod = eclass.DefineMethod(func.getName(),
 292                         MethodAttributes.Static|MethodAttributes.Public,
 293                         funcsig, paramTypes);
 294   func.setMethodBuilder(emethod); // save the method ref
 295
 296   /*
 297    * set the argument symbol info
 298    */
 299   for (int i = 0; i < paramlist.Length(); i++)
 300     emethod.DefineParameter(i+1, 0, paramlist.FindByIndex(i).getName());
 301
 302   il = emethod.GetILGenerator(); // create new il generator
 303
 304   if (func.getName().Equals("main")) /* special entry point for main */
 305     appbuild.SetEntryPoint(emethod);
 306     //    emodule.SetUserEntryPoint(emethod);
 307
 308   /*
 309    * must also re-init the label hashtable for each function
 310    */
 311   labelhash = new Hashtable();
 312
 313   localsdone = false;
 314   }
 315
 316 public void Call(IAsm a)
 317   {
 318   Var func = a.getVar();
 319   Object o = func.getMethodBuilder(); // get previous declared reference
 320   if (o == null)
 321     Io.ICE("No previous extern for (" + func.getName() + ")");
 322   MethodBuilder mb = (MethodBuilder) o;
 323 //  il.Emit(OpCodes.Ldc_I4_0);  // push 0 for the "this" ptr
 324 //  VarList x = func.getParams(); /* get any params */
 325 //  if (x.Length() > 0)
 326 //    {
 327 //    int max = x.Length();
 328 //    for (int i = 0; i < max; i++)
 329 //      {
 330 //      Var e = x.FindByIndex(i);
 331 //      genLoad(e);
 332 //      }
 333 //    }
 334   il.Emit(OpCodes.Call, mb);    // call the MethodBuilder
 335   }
 336
 337 public void Insn(IAsm a)
 338   {
 339   Object o = opcodehash[a.getInsn()];
 340   if (o == null)
 341     Io.ICE("Instruction opcode (" + a.getInsn() + ") not found in hash");
 342   il.Emit((OpCode) o);
 343   }
 344
 345 private Hashtable labelhash;    /* labelname hashtable */
 346 /*
 347  * get and/or create IL label
 348  * put it in hash for reuse
 349  */
 350 private Object getILLabel(IAsm a)
 351   {
 352   String s = a.getLabel();
 353   Object l = labelhash[s];
 354   if (l == null)
 355     {
 356     l = (Object) il.DefineLabel();
 357     labelhash[s] = l;
 358     }
 359   return l;
 360   }
 361
 362 public void Label(IAsm a)
 363   {
 364   il.MarkLabel((Label) getILLabel(a));
 365   }
 366
 367 public void Branch(IAsm a)
 368   {
 369   Object o = opcodehash[a.getInsn()];
 370   if (o == null)
 371     Io.ICE("Instruction branch opcode (" + a.getInsn() + ") not found in hash");
 372   il.Emit((OpCode) o, (Label) getILLabel(a));
 373   }
 374
 375 public void Ret(IAsm a)
 376   {
 377   il.Emit(OpCodes.Ret);
 378   }
 379
 380 public void FuncEnd()
 381   {
 382   /*
 383    * fill in the current IL stream for this method
 384    */
 385   //  emethod.CreateMethodBody(il);
 386   il = null;
 387   localsdone = false;
 388   }
 389
 390 public void LocalVars(VarList v)
 391   {
 392   int max = v.Length();
 393
 394   for (int i = 0; i < max; i++) // loop thru the local params
 395     {
 396     Var e = v.FindByIndex(i);   // indexed by number
 397     Type et = genDataTypeSig(e);
 398     //    LocalToken t = emethod.DeclareLocal(et);
 399     LocalBuilder t = il.DeclareLocal(et);
 400     if (Io.gendebug)
 401       t.SetLocalSymInfo(e.getName());
 402     e.setLocalToken(t);
 403     }
 404   localsdone = true;
 405   }
 406
 407 public void FieldDef(IAsm a)
 408   {
 409   Var e = a.getVar();                   /* get the field var ptr */
 410   FieldAttributes attr = FieldAttributes.Private; /* default attributes is private */
 411
 412   if (e.getClassId() == Tok.T_STATIC)
 413     attr |= FieldAttributes.Static;
 414
 415   Type t = genDataTypeSig(e);           /* gen type info */
 416
 417   FieldBuilder f = eclass.DefineField(e.getName(), t, attr); // returns token
 418   e.setFieldBuilder((Object) f);                        // store token for later usage
 419   }
 420
 421 public void LoadConst(IAsm a)
 422   {
 423   int value = Convert.ToInt32(a.getInsn());
 424
 425   if (value > 127 || value < -128) /* if must use long form */
 426     {
 427     il.Emit(OpCodes.Ldc_I4, value);
 428     }
 429   else if (value > 8 || value < -1)     /* if must use medium form */
 430     {
 431     il.Emit(OpCodes.Ldc_I4_S, value);
 432     }
 433   else if (value == -1)
 434     {
 435     il.Emit(OpCodes.Ldc_I4_M1);
 436     }
 437   else                          /* else use short form */
 438     {
 439     Object o = opcodehash["ldc.i4."+a.getInsn()];
 440     if (o == null)
 441       Io.ICE("Could not find opcode for (Ldc_I4_" + a.getInsn() + ")");
 442     il.Emit((OpCode) o);
 443     }
 444   }
 445
 446 public void Comment(IAsm a)
 447   {
 448   if (Io.gendebug)
 449     {
 450     if (localsdone)
 451       {
 452       if (a != null && il != null)
 453         {
 454         if (!IsNextNonInsnGen(a))
 455           {
 456
 457           //      Console.WriteLine("Line ("+a.getCommentLine().ToString()+")="+a.getComment());
 458           int l = a.getCommentLine();
 459           il.MarkSequencePoint(srcdoc, l, 0, l, 0);
 460           }
 461         }
 462       }
 463     }
 464   }
 465
 466 /*
 467  * is the next assembler directive an non-instruction generation
 468  *
 469  * this is used to keep marksequencepoint from getting multiple calls
 470  * with no intervening instructions, which causes it to work incorrectly
 471  */
 472 private bool IsNextNonInsnGen(IAsm a)
 473   {
 474   IAsm cur = a.getNext();
 475   if (cur == null)
 476     return true;
 477   int type = cur.getIType();
 478
 479   /*
 480    * skip intervening labels
 481    */
 482   while (type == IAsm.I_LABEL)
 483     {
 484     cur = cur.getNext();
 485     type = cur.getIType();
 486     }
 487
 488   /*
 489    * if next is comment then return true
 490    */
 491   if (type == IAsm.I_COMMENT)
 492     return true;
 493   return false;
 494   }
 495
 496 }
 497
 498 }